home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / BARMDI.PAK / BARMDI.C < prev    next >
C/C++ Source or Header  |  1997-05-06  |  16KB  |  590 lines
  1. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  2. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  3. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  4. // PARTICULAR PURPOSE.
  5. //
  6. // Copyright (C) 1993-1995  Microsoft Corporation.  All Rights Reserved.
  7. //
  8. //  MODULE:   barmdi.c
  9. //
  10. //  PURPOSE:  Implement the window procedure for the main application
  11. //            window.
  12. //
  13. //  FUNCTIONS:
  14. //    WndProc           - Processes messages for the main window.
  15. //    MsgCreate         - To create the MDI client window.
  16. //    MsgCommand        - Handle the WM_COMMAND messages for the main window.
  17. //    MsgDestroy        - Handles the WM_DESTROY message by calling
  18. //                        PostQuitMessage().
  19. //    CmdFileNew        - To create a new mdi child window.
  20. //    CmdWindowTile     - To tile the mdi child windows.
  21. //    CmdWindowCascade  - To cascade the mdi child windows.
  22. //    CmdWindowIcons    - To arrage the mdi child icons.
  23. //    CmdWindowCloseAll - To close all of the mdi child windows.
  24. //    CmdExit           - Handles the file exit command by calling destory
  25. //                        window on the main window.
  26. //
  27. //  COMMENTS:
  28. //    Message dispatch table -
  29. //      For every message to be handled by the main window procedure
  30. //      place the message number and handler function pointer in
  31. //      rgmsd (the message dispatch table).  Place the prototype
  32. //      for the function in globals.h and the definition of the
  33. //      function in the appropriate module.
  34. //    Command dispatch table -
  35. //      For every command to be handled by the main window procedure
  36. //      place the command number and handler function pointer in
  37. //      rgcmd (the command dispatch table).  Place the prototype
  38. //      for the function in globals.h and the definition of the
  39. //      function in the appropriate module.
  40. //    Globals.h Contains the definitions of the structures and dispatch.c
  41. //      contains the functions that use these structures.
  42. //
  43.  
  44. #include <windows.h>            // required for all Windows applications
  45. #include <windowsx.h>
  46. #include <commctrl.h>
  47. #include "globals.h"            // prototypes specific to this application
  48. #include "toolbar.h"
  49. #include "statbar.h"
  50. #include "resource.h"
  51.  
  52.  
  53. // Main window message table definition.
  54. MSD rgmsd[] =
  55. {
  56.     {WM_INITMENU,   MsgInitMenu},
  57.     {WM_COMMAND,    MsgCommand},
  58.     {WM_CREATE,     MsgCreate},
  59.     {WM_DESTROY,    MsgDestroy},
  60.     {WM_MENUSELECT, MsgMenuSelect},
  61.     {WM_NOTIFY,     MsgNotify},
  62.     {WM_TIMER,      MsgTimer},
  63.     {WM_SIZE,       MsgSize},
  64. };
  65.  
  66. MSDI msdiMain =
  67. {
  68.     sizeof(rgmsd) / sizeof(MSD),
  69.     rgmsd,
  70.     edwpMDIFrame
  71. };
  72.  
  73.  
  74. // Main window command table definition.
  75. CMD rgcmd[] =
  76. {
  77.     {IDM_FILENEW,       CmdFileNew},
  78.     {IDM_FILECLOSE,     CmdFileClose},
  79.     {IDM_EXIT,          CmdExit},
  80.     {IDM_ABOUT,         CmdAbout},
  81.     {IDM_WINDOWTILE,    CmdWindowTile},
  82.     {IDM_WINDOWCASCADE, CmdWindowCascade},
  83.     {IDM_WINDOWICONS,   CmdWindowIcons},
  84.     {IDM_WINDOWCLOSEALL,CmdWindowCloseAll}
  85. };
  86.  
  87. CMDI cmdiMain =
  88. {
  89.     sizeof(rgcmd) / sizeof(CMD),
  90.     rgcmd,
  91.     edwpMDIFrame
  92. };
  93.  
  94. // Module specific globals
  95.  
  96. HWND hwndMDIClient = NULL;      // The MDI client window handle.
  97. UINT cUntitled = 1;
  98. UINT cOpen = 0;
  99. extern char szChildName[];
  100.  
  101.  
  102. //
  103. //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
  104. //
  105. //  PURPOSE:  Processes messages for the main window.
  106. //
  107. //  PARAMETERS:
  108. //    hwnd     - window handle
  109. //    uMessage - message number
  110. //    wparam   - additional information (dependant on message number)
  111. //    lparam   - additional information (dependant on message number)
  112. //
  113. //  RETURN VALUE:
  114. //    The return value depends on the message number.  If the message
  115. //    is implemented in the message dispatch table, the return value is
  116. //    the value returned by the message handling function.  Otherwise,
  117. //    the return value is the value returned by the default window procedure.
  118. //
  119. //  COMMENTS:
  120. //    Call the DispMessage() function with the main window's message dispatch
  121. //    information (msdiMain) and the message specific information.
  122. //
  123.  
  124. LRESULT CALLBACK WndProc(HWND   hwnd,
  125.                          UINT   uMessage,
  126.                          WPARAM wparam,
  127.                          LPARAM lparam)
  128. {
  129.     return DispMessage(&msdiMain, hwnd, uMessage, wparam, lparam);
  130. }
  131.  
  132.  
  133. //
  134. //  FUNCTION: MsgCreate(HWND, UINT, WPARAM, LPARAM)
  135. //
  136. //  PURPOSE: To create an MDI client window.
  137. //
  138. //  PARAMETERS:
  139. //    hwnd - The window handing the message.
  140. //    uMessage - WM_CREATE (unused)
  141. //    wparam - Message specific data (unused).
  142. //    lparam - Message specific data (unused).
  143. //
  144. //  RETURN VALUE:
  145. //    Always returns 0 - message handled.
  146. //
  147. //  COMMENTS:
  148. //
  149. //
  150.  
  151. #pragma argsused
  152. LRESULT MsgCreate(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  153. {
  154.     CLIENTCREATESTRUCT ccs = {0};
  155.  
  156.     InitCommonControls();   // Initialize the common control library.
  157.  
  158.     CreateTBar(hwnd);       // Create tool bar
  159.     CreateSBar(hwnd);       // Create status bar
  160.  
  161.     // Find window menu where children will be listed
  162.     ccs.hWindowMenu  = GetSubMenu(GetMenu(hwnd), WINDOWMENU);
  163.     ccs.idFirstChild = IDM_WINDOWCHILD;
  164.  
  165.     // Create the MDI client filling the client area
  166.     hwndMDIClient = CreateWindow("mdiclient",
  167.                                  NULL,
  168.                                  WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL |
  169.                                  WS_HSCROLL,
  170.                                  0, 0, 0, 0,
  171.                                  hwnd,
  172.                                  (HMENU)0xCAC,
  173.                                  hInst,
  174.                                  (LPVOID)&ccs);
  175.  
  176.     ShowWindow(hwndMDIClient, SW_SHOW);
  177.  
  178.     return 0;
  179. }
  180.  
  181.  
  182. //
  183. //  FUNCTION: MsgCommand(HWND, UINT, WPARAM, LPARAM)
  184. //
  185. //  PURPOSE: Handle the WM_COMMAND messages for the main window.
  186. //
  187. //  PARAMETERS:
  188. //    hwnd     - window handle
  189. //    uMessage - WM_COMMAND (Unused)
  190. //    GET_WM_COMMAND_ID(wparam, lparam)   - Command identifier
  191. //    GET_WM_COMMAND_HWND(wparam, lparam) - Control handle
  192. //
  193. //  RETURN VALUE:
  194. //    The return value depends on the message number.  If the message
  195. //    is implemented in the message dispatch table, the return value is
  196. //    the value returned by the message handling function.  Otherwise,
  197. //    the return value is the value returned by the default window procedure.
  198. //
  199. //  COMMENTS:
  200. //    Call the DispCommand() function with the main window's command dispatch
  201. //    information (cmdiMain) and the command specific information.
  202. //
  203.  
  204. #pragma argsused
  205. LRESULT MsgCommand(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  206. {
  207.      return DispCommand(&cmdiMain, hwnd, wparam, lparam);
  208. }
  209.  
  210.  
  211. //
  212. //  FUNCTION: MsgInitMenu(HWND, UINT, WPARAM, LPARAM)
  213. //
  214. //  PURPOSE: Enable/Disable the close menu command.
  215. //
  216. //  PARAMETERS:
  217. //
  218. //    hwnd      - Window handle
  219. //    uMessage  - Message number (Unused)
  220. //    wparam    - HMENU - The menu about to be activated
  221. //    lparam    - Extra data     (Unused)
  222. //
  223. //  RETURN VALUE:
  224. //
  225. //    0 - The message was handled.
  226. //    1 - The message was not handled - wrong menu.
  227. //
  228. //  COMMENTS:
  229. //
  230. //
  231.  
  232. #pragma argsused
  233. LRESULT MsgInitMenu(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  234. {
  235.     if (GetMenu(hwnd) == (HMENU)wparam)
  236.     {
  237.         UINT mf = (cOpen) ? MF_ENABLED : MF_GRAYED;
  238.  
  239.         EnableMenuItem((HMENU)wparam, IDM_FILECLOSE, mf);
  240.  
  241.         return 0;
  242.     }
  243.     else
  244.     {
  245.           return 1;
  246.     }
  247. }
  248.  
  249.  
  250. //
  251. //  FUNCTION: MsgDestroy(HWND, UINT, WPARAM, LPARAM)
  252. //
  253. //  PURPOSE: Calls PostQuitMessage().
  254. //
  255. //  PARAMETERS:
  256. //
  257. //    hwnd      - Window handle  (Unused)
  258. //    uMessage  - Message number (Unused)
  259. //    wparam    - Extra data     (Unused)
  260. //    lparam    - Extra data     (Unused)
  261. //
  262. //  RETURN VALUE:
  263. //
  264. //    Always returns 0 - Message handled
  265. //
  266. //  COMMENTS:
  267. //
  268. //
  269.  
  270. #pragma argsused
  271. LRESULT MsgDestroy(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  272. {
  273.     PostQuitMessage(0);
  274.     return 0;
  275. }
  276.  
  277.  
  278. //
  279. //  FUNCTION: MsgSize(HWND, UINT, WPARAM, LPARAM)
  280. //
  281. //  PURPOSE:  This function resizes the toolbar and statusbar controls.
  282. //
  283. //
  284. //  PARAMETERS:
  285. //
  286. //    hwnd      - Window handle  (Used)
  287. //    uMessage  - Message number (Used)
  288. //    wparam    - Extra data     (Used)
  289. //    lparam    - Extra data     (Used)
  290. //
  291. //  RETURN VALUE:
  292. //
  293. //    Always returns 0 - Message handled
  294. //
  295. //  COMMENTS:
  296. //
  297. //    When the window procdure that has the status and tool bar controls
  298. //    receive the WM_SIZE message, it has to pass the message on to these
  299. //    controls so that these controls can adjust their size accordingly.
  300. //
  301. //
  302.  
  303. LRESULT MsgSize(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
  304. {
  305.     SendMessage(hWndToolbar, uMessage, wparam, lparam);
  306.     SendMessage(hWndStatusbar,  uMessage, wparam, lparam);
  307.  
  308.     // Re-position the panes in the status bar
  309.     InitializeStatusBar(hwnd);
  310.  
  311.     // Position the MDI client window between the tool and status bars
  312.     if (wparam != SIZE_MINIMIZED)
  313.     {
  314.         RECT rc, rcClient;
  315.  
  316.         GetClientRect(hwnd, &rcClient);
  317.  
  318.         GetWindowRect(hWndToolbar, &rc);
  319.         ScreenToClient(hwnd, (LPPOINT)&rc.right);
  320.         rcClient.top = rc.bottom;
  321.  
  322.         GetWindowRect(hWndStatusbar, &rc);
  323.         ScreenToClient(hwnd, (LPPOINT)&rc.left);
  324.         rcClient.bottom = rc.top;
  325.  
  326.         MoveWindow(hwndMDIClient,
  327.                    rcClient.left,
  328.                    rcClient.top,
  329.                    rcClient.right-rcClient.left,
  330.                    rcClient.bottom-rcClient.top,
  331.                    TRUE);
  332.     }
  333.  
  334.     return 0 ;
  335. }
  336.  
  337.  
  338. //
  339. //  FUNCTION: CmdFileNew(HWND, WORD, WORD, HWND)
  340. //
  341. //  PURPOSE: To create a new mdi child window.
  342. //
  343. //  PARAMETERS:
  344. //    hwnd - The window handling the command.
  345. //    wCommand - IDM_FILENEW (unused)
  346. //    hwndCtrl - NULL (unused).
  347. //
  348. //  RETURN VALUE:
  349. //    Always returns 0 - command handled.
  350. //
  351. //  COMMENTS:
  352. //
  353. //
  354.  
  355. #pragma argsused
  356. LRESULT CmdFileNew(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  357. {
  358.     HWND  hwndChild;
  359.     char  rgch[15];
  360.     DWORD dwVersion;
  361.  
  362.     wsprintf(rgch,"Untitled%d", cUntitled);
  363.  
  364.     // Create the MDI child window
  365.  
  366.     // Windows NT and Windows 95 present different options for creating
  367.      // an MDI child window.  While using the WM_MDICREATE message will
  368.     // work on both Windows versions, Windows 95 presents a new window
  369.     // style which simplifies the process.  Here the function uses the
  370.     // method apropriate for the system it's running on.
  371.  
  372.     dwVersion = GetVersion();
  373.     if ((dwVersion < 0x80000000) || (LOBYTE(LOWORD(dwVersion)) < 4))
  374.     {
  375.         // This is Windows NT or Win32s, so use the WM_MDICREATE message
  376.         MDICREATESTRUCT mcs;
  377.  
  378.         mcs.szClass = szChildName;      // window class name
  379.         mcs.szTitle = rgch;             // window title
  380.         mcs.hOwner  = hInst;            // owner
  381.         mcs.x       = CW_USEDEFAULT;    // x position
  382.           mcs.y       = CW_USEDEFAULT;    // y position
  383.         mcs.cx      = CW_USEDEFAULT;    // width
  384.         mcs.cy      = CW_USEDEFAULT;    // height
  385.         mcs.style   = 0;                // window style
  386.         mcs.lParam  = 0;                // lparam
  387.  
  388.         hwndChild = (HWND) SendMessage(hwndMDIClient,
  389.                                        WM_MDICREATE,
  390.                                        0,
  391.                                        (LPARAM)(LPMDICREATESTRUCT) &mcs);
  392.     }
  393.     else
  394.     {
  395.         // This method will only work with Windows 95, not Windows NT or Win32s
  396.         hwndChild = CreateWindowEx(WS_EX_MDICHILD,  // EX window style
  397.                                               szChildName,     // window class name
  398.                                    rgch,            // window title
  399.                                    0,               // window style
  400.                                    CW_USEDEFAULT,   // x position
  401.                                    CW_USEDEFAULT,   // y position
  402.                                    CW_USEDEFAULT,   // width
  403.                                    CW_USEDEFAULT,   // height
  404.                                    hwndMDIClient,   // parent
  405.                                    NULL,            // menu (child ID)
  406.                                    hInst,           // owner
  407.                                    0);              // lparam
  408.     }
  409.  
  410.     if (hwndChild != NULL)
  411.         ShowWindow(hwndChild, SW_SHOW);
  412.  
  413.     cUntitled++;
  414.     cOpen++;
  415.     return 0;
  416. }
  417.  
  418.  
  419. //
  420. //  FUNCTION: CmdExit(HWND, WORD, WORD, HWND)
  421. //
  422. //  PURPOSE: Exit the application.
  423. //
  424. //  PARAMETERS:
  425. //    hwnd     - The window.
  426. //    wCommand - IDM_EXIT (unused)
  427. //    wNotify  - Notification number (unused)
  428. //    hwndCtrl - NULL (unused)
  429. //
  430. //  RETURN VALUE:
  431. //    Always returns 0 - command handled.
  432. //
  433. //  COMMENTS:
  434. //
  435. //
  436.  
  437. #pragma argsused
  438. LRESULT CmdExit(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  439. {
  440.     DestroyWindow(hwnd);
  441.     return 0;
  442. }
  443.  
  444.  
  445. //
  446. //  FUNCTION: CmdFileClose(HWND, WORD, WORD, HWND)
  447. //
  448. //  PURPOSE: To close the active mdi child window.
  449. //
  450. //  PARAMETERS:
  451. //    hwnd - The window handling the command.
  452. //    wCommand - IDM_FILECLOSE (unused).
  453. //    hwndCtrl - NULL (unused).
  454. //
  455. //  RETURN VALUE:
  456. //    Always returns 0 - command handled.
  457. //
  458. //  COMMENTS:
  459. //
  460. //
  461.  
  462. #pragma argsused
  463. LRESULT CmdFileClose(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  464. {
  465.      HWND hwndT;
  466.  
  467.     hwndT = (HWND)SendMessage(hwndMDIClient, WM_MDIGETACTIVE, 0, 0L);
  468.     if (hwndT != NULL)
  469.         SendMessage(hwndMDIClient, WM_MDIDESTROY, (WPARAM)hwndT, 0L);
  470.  
  471.     return 0;
  472. }
  473.  
  474.  
  475. //
  476. //  FUNCTION: CmdWindowTile(HWND, WORD, WORD, HWND)
  477. //
  478. //  PURPOSE: To tile the mdi child windows.
  479. //
  480. //  PARAMETERS:
  481. //    hwnd - The window handling the command.
  482. //    wCommand - IDM_WINDOWTILE (unused).
  483. //    hwndCtrl - NULL (unused).
  484. //
  485. //  RETURN VALUE:
  486. //    Always returns 0 - command handled.
  487. //
  488. //  COMMENTS:
  489. //
  490. //
  491.  
  492. #pragma argsused
  493. LRESULT CmdWindowTile(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  494. {
  495.     SendMessage(hwndMDIClient, WM_MDITILE, 0, 0L);
  496.  
  497.     return 0;
  498. }
  499.  
  500. //
  501. //  FUNCTION: CmdWindowCascade(HWND, WORD, WORD, HWND)
  502. //
  503. //  PURPOSE: To cascade the mdi child windows.
  504. //
  505. //  PARAMETERS:
  506. //    hwnd - The window handling the command.
  507. //    wCommand - IDM_WINDOWCASCADE (unused).
  508. //    hwndCtrl - NULL (unused).
  509. //
  510. //  RETURN VALUE:
  511. //    Always returns 0 - command handled.
  512. //
  513. //  COMMENTS:
  514. //
  515. //
  516.  
  517. #pragma argsused
  518. LRESULT CmdWindowCascade(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  519. {
  520.     SendMessage(hwndMDIClient, WM_MDICASCADE, 0, 0L);
  521.  
  522.     return 0;
  523. }
  524.  
  525. //
  526. //  FUNCTION: CmdWindowIcons(HWND, WORD, WORD, HWND)
  527. //
  528. //  PURPOSE: To arrage the mdi child icons.
  529. //
  530. //  PARAMETERS:
  531. //    hwnd - The window handling the command.
  532. //    wCommand - IDM_WINDOWICONS (unused).
  533. //    hwndCtrl - NULL (unused).
  534. //
  535. //  RETURN VALUE:
  536. //    Always returns 0 - command handled.
  537. //
  538. //  COMMENTS:
  539. //
  540. //
  541.  
  542. #pragma argsused
  543. LRESULT CmdWindowIcons(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  544. {
  545.     SendMessage(hwndMDIClient, WM_MDIICONARRANGE, 0, 0L);
  546.  
  547.     return 0;
  548. }
  549.  
  550. //
  551. //  FUNCTION: CmdWindowCloseAll(HWND, WORD, WORD, HWND)
  552. //
  553. //  PURPOSE: To close all of the mdi child windows.
  554. //
  555. //  PARAMETERS:
  556. //    hwnd - The window handling the command.
  557. //    wCommand - IDM_WINDOWCLOSEALL (unused).
  558. //    hwndCtrl - NULL (unused).
  559. //
  560. //  RETURN VALUE:
  561. //    Always returns 0 - command handled.
  562. //
  563. //  COMMENTS:
  564. //
  565. //
  566.  
  567. #pragma argsused
  568. #pragma warn -pia
  569. LRESULT CmdWindowCloseAll(HWND hwnd, WORD wCommand, WORD wNotify, HWND hwndCtrl)
  570. {
  571.     HWND hwndT;
  572.  
  573.     // As long as the MDI client has a child, destroy it
  574.     while (hwndT = GetWindow(hwndMDIClient, GW_CHILD))
  575.     {
  576.  
  577.         // Skip the icon and title windows
  578.           while (hwndT && GetWindow(hwndT, GW_OWNER))
  579.             hwndT = GetWindow(hwndT, GW_HWNDNEXT);
  580.  
  581.         if (hwndT)
  582.             SendMessage(hwndMDIClient, WM_MDIDESTROY, (WPARAM)hwndT, 0L);
  583.           else
  584.                 break;
  585.      }
  586.  
  587.      return 0;
  588. }
  589. #pragma warn .pia
  590.